home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / clients / xmag / scale.c < prev    next >
Text File  |  1994-08-12  |  28KB  |  1,028 lines
  1. /*
  2.  * $XConsortium: Scale.c,v 1.15 91/08/26 11:00:15 gildea Exp $
  3.  *
  4.  * Copyright 1989 Massachusetts Institute of Technology
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of M.I.T. not be used in advertising or
  11.  * publicity pertaining to distribution of the software without specific,
  12.  * written prior permission.  M.I.T. makes no representations about the
  13.  * suitability of this software for any purpose.  It is provided "as is"
  14.  * without express or implied warranty.
  15.  *
  16.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  18.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  *
  23.  * Author:  Davor Matic, MIT X Consortium
  24.  */
  25.  
  26.  
  27. #include <stdio.h>
  28. #include <ctype.h>
  29. #include <string.h> 
  30. #include <math.h>
  31. #ifdef MSDOS
  32. #include "X11/IntrinsP.h"      /* QDK 05/17/1994  4:19pm. */
  33. #else
  34. #include "X11/IntrinsicP.h"
  35. #endif
  36. #include <X11/StringDefs.h>
  37. #include <X11/Xaw/XawInit.h>
  38. #include "ScaleP.h"
  39. #include <X11/Xosdefs.h>
  40.  
  41. #define myrint(x) floor(x + 0.5)
  42.  
  43. #ifndef X_NOT_STDC_ENV
  44. #include <stdlib.h>
  45. #endif
  46.  
  47. #if defined(ISC) && defined(SYSV) && defined(SYSV386) && __STDC__
  48. extern double atof(char *);
  49. #endif
  50.  
  51. #define streq(a,b) (strcmp( (a), (b) ) == 0)
  52. #if !defined(__WATCOMC__)
  53. #define min(x, y) (x > y ? y : x)
  54. #define max(x, y) (x < y ? y : x)
  55. #endif
  56.  
  57. #define DefaultBufferSize 1024
  58. #define DefaultScaleFactor NULL
  59.  
  60. #define Offset(field) XtOffsetOf(ScaleRec, scale.field)
  61.  
  62. static XtResource resources[] = {
  63. {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  64.      Offset(foreground_pixel), XtRString, (XtPointer) XtDefaultForeground},
  65. {XtNgravity, XtCGravity, XtRGravity, sizeof(XtGravity),
  66.      Offset(gravity), XtRImmediate, (XtPointer) "ForgetGravity"},
  67. {XtNinternalWidth, XtCWidth, XtRDimension,  sizeof(Dimension),
  68.      Offset(internal_width), XtRImmediate, (XtPointer) 2},
  69. {XtNinternalHeight, XtCHeight, XtRDimension, sizeof(Dimension),
  70.      Offset(internal_height), XtRImmediate, (XtPointer) 2},
  71. {XtNresize, XtCResize, XtRBoolean, sizeof(Boolean),
  72.      Offset(resize), XtRImmediate, (XtPointer) True},
  73. {XtNautoscale, XtCAutoscale, XtRBoolean, sizeof(Boolean),
  74.      Offset(autoscale), XtRImmediate, (XtPointer) True},
  75. {XtNproportional, XtCProportional, XtRBoolean, sizeof(Boolean),
  76.      Offset(proportional), XtRImmediate, (XtPointer) True},
  77. {XtNscaleX, XtCScaleFactor, XtRString, sizeof(String),
  78.      Offset(scale_x_str), XtRImmediate, (XtPointer) DefaultScaleFactor},
  79. {XtNscaleY, XtCScaleFactor, XtRString, sizeof(String),
  80.      Offset(scale_y_str), XtRImmediate, (XtPointer) DefaultScaleFactor},
  81. {XtNaspectRatio, XtCAspectRatio, XtRString, sizeof(String),
  82.      Offset(aspect_ratio_str), XtRImmediate, (XtPointer) "1.0"},
  83. {XtNprecision, XtCPrecision, XtRString, sizeof(String),
  84.      Offset(precision_str), XtRImmediate, (XtPointer) "0.001"},
  85. {XtNimage, XtCImage, XtRImage, sizeof(XImage*),
  86.      Offset(image), XtRImmediate, (XtPointer) NULL},
  87. {XtNpasteBuffer, XtCPasteBuffer, XtRBoolean, sizeof(Boolean),
  88.      Offset(paste_buffer), XtRImmediate, (XtPointer) False},
  89. {XtNbufferSize, XtCBufferSize, XtRCardinal, sizeof(Cardinal),
  90.      Offset(buffer_size), XtRImmediate, (XtPointer) DefaultBufferSize},
  91. {XtNuserData, XtCuserData, XtRuserData, sizeof(XtPointer),
  92.      Offset(userData), XtRImmediate, (XtPointer) NULL},
  93. { XtNvisual, XtCvisual, XtRVisual, sizeof(Visual*),
  94.      Offset(visual), XtRImmediate, CopyFromParent}
  95. };
  96.  
  97. #undef Offset
  98.  
  99. static void ClassInitialize();
  100. static void Initialize();
  101. static void Realize();
  102. static void Redisplay();
  103. static void Resize();
  104. static void Destroy();
  105. static Boolean SetValues();
  106.  
  107. void SWUnscale();
  108. void SWAutoscale();
  109. void SWInitialSize();
  110. void RequestSelection();
  111. void GrabSelection();
  112.  
  113. static XtActionsRec actions[] =
  114. {
  115. {"unscale", SWUnscale},
  116. {"autoscale", SWAutoscale},
  117. {"initial-size", SWInitialSize},
  118. {"paste", RequestSelection},
  119. {"cut", GrabSelection}
  120. };
  121.  
  122. static char translations[] =
  123. "\
  124.  <Key>u:           unscale()\n\
  125.  <Key>a:           autoscale()\n\
  126.  <Key>i:           initial-size()\n\
  127. ";
  128.  
  129. ScaleClassRec scaleClassRec = {
  130. {   /* core fields */
  131.     /* superclass        */    (WidgetClass) &simpleClassRec,
  132.     /* class_name        */    "Scale",
  133.     /* widget_size        */    sizeof(ScaleRec),
  134.     /* class_initialize        */    ClassInitialize,
  135.     /* class_part_initialize    */    NULL,
  136.     /* class_inited        */    FALSE,
  137.     /* initialize        */    Initialize,
  138.     /* initialize_hook        */    NULL,
  139.     /* realize            */    Realize,
  140.     /* actions            */    actions,
  141.     /* num_actions        */    XtNumber(actions),
  142.     /* resources        */    resources,
  143.     /* num_resources        */    XtNumber(resources),
  144.     /* xrm_class        */    NULLQUARK,
  145.     /* compress_motion        */    TRUE,
  146.     /* compress_exposure    */      XtExposeCompressMaximal|
  147.                                         XtExposeGraphicsExposeMerged,
  148.     /* compress_enterleave    */    TRUE,
  149.     /* visible_interest        */    TRUE,
  150.     /* destroy            */    Destroy,
  151.     /* resize            */    Resize,
  152.     /* expose            */    Redisplay,
  153.     /* set_values        */    SetValues,
  154.     /* set_values_hook        */    NULL,
  155.     /* set_values_almost    */    XtInheritSetValuesAlmost,
  156.     /* get_values_hook        */    NULL,
  157.     /* accept_focus        */    NULL,
  158.     /* version            */    XtVersion,
  159.     /* callback_private        */    NULL,
  160.     /* tm_table            */      translations,
  161.     /* query_geometry        */    XtInheritQueryGeometry,
  162.     /* display_accelerator    */    XtInheritDisplayAccelerator,
  163.     /* extension        */    NULL
  164.   },
  165.   { 
  166.     /* change_sensitive        */    XtInheritChangeSensitive,
  167.   }
  168. };
  169.  
  170. WidgetClass scaleWidgetClass = (WidgetClass) &scaleClassRec;
  171.     
  172.  
  173.  
  174. /*
  175.  * Private Procedures
  176.  */
  177.  
  178.  
  179. static void ClassInitialize()
  180. {
  181. } 
  182.  
  183.  
  184.  
  185. void GetGC(sw)
  186.     ScaleWidget sw;
  187. {
  188.     XGCValues values;
  189.     
  190.     values.foreground = sw->scale.foreground_pixel;
  191.     values.background = sw->core.background_pixel;
  192.     values.function = GXcopy;
  193.     
  194.     sw->scale.gc = XtGetGC((Widget) sw,
  195.                GCForeground | 
  196.                GCBackground | 
  197.                GCFunction,
  198.                &values);
  199. }
  200.  
  201.  
  202.  
  203. void Proportional();
  204.  
  205. void GetInitialScaleValues(sw)
  206.     ScaleWidget sw;
  207. {
  208.     if (sw->scale.proportional) {
  209.     sw->scale.scale_x = sw->scale.scale_y =
  210.         ((sw->scale.aspect_ratio > 1.0) ?
  211.          sw->scale.aspect_ratio : 1.0 / sw->scale.aspect_ratio) *
  212.          (sw->scale.precision > 1.0 ?
  213.           sw->scale.precision : 1.0);
  214.     Proportional(sw); /* need to cut them down to proper values */
  215.     }
  216.     else
  217.     sw->scale.scale_x = sw->scale.scale_y = 1.0;
  218. }
  219.  
  220.  
  221.  
  222. void GetRectangleBuffer(sw, buffer_size)
  223.     ScaleWidget sw;
  224.     Cardinal buffer_size;
  225.     /*
  226.      * This procedure will realloc a new rectangles buffer.
  227.      * If the new buffer size is less than nrectangles, some
  228.      * information will be lost.
  229.      */
  230. {
  231.     if (buffer_size == 0) {
  232.     buffer_size = DefaultBufferSize;
  233.     XtWarning("buffer size has to be a positive number greater than zero");
  234.     }
  235.     sw->scale.rectangles = (XRectangle *)
  236.     XtRealloc((char *) sw->scale.rectangles, 
  237.           buffer_size * sizeof(XRectangle));
  238.     sw->scale.buffer_size = buffer_size;
  239. }
  240.  
  241.  
  242.  
  243. /* ARGSUSED */
  244. static void Initialize(request, new)
  245.     Widget request, new;
  246. {
  247.     ScaleWidget new_sw = (ScaleWidget) new;
  248.     
  249.     new_sw->scale.table.x = (Position *) NULL;
  250.     new_sw->scale.table.y = (Position *) NULL;
  251.     new_sw->scale.table.width = (Dimension *) NULL;
  252.     new_sw->scale.table.height = (Dimension *) NULL;
  253.     
  254.     new_sw->scale.nrectangles = 0;
  255.     new_sw->scale.rectangles = (XRectangle *) NULL;
  256.     
  257.     GetRectangleBuffer(new_sw, new_sw->scale.buffer_size);
  258.     
  259.     GetGC(new_sw);
  260.     
  261.     if (new_sw->scale.image != NULL) {
  262.     if (new_sw->core.width == 0)
  263.         new_sw->core.width = 
  264.         new_sw->scale.image->width + 2 * new_sw->scale.internal_width;
  265.     if (new_sw->core.height == 0)
  266.         new_sw->core.height = 
  267.         new_sw->scale.image->height + 2 *new_sw->scale.internal_height;
  268.     }
  269.     else {
  270.     if (new_sw->core.width == 0)
  271.         new_sw->core.width = 1 + 2 * new_sw->scale.internal_width;
  272.     if (new_sw->core.height == 0)
  273.         new_sw->core.height = 1 + 2 * new_sw->scale.internal_height;
  274.     new_sw->scale.image = XCreateImage(XtDisplay(new),
  275.                        DefaultVisual(XtDisplay(new), 
  276.                             DefaultScreen(XtDisplay(new))),
  277.                        1, XYBitmap, 0, 
  278.                        XtCalloc(1, sizeof(char)),
  279.                        1, 1, 8, 0);
  280.     }
  281.  
  282.     if ((new_sw->scale.aspect_ratio = 
  283.      atof(new_sw->scale.aspect_ratio_str)) < 0.0) {
  284.     new_sw->scale.aspect_ratio = 1.0;
  285.     XtWarning("AspectRatio has to be a positive number. (forced to 1.0)");
  286.     }
  287.  
  288.     if ((new_sw->scale.precision =
  289.          atof(new_sw->scale.precision_str)) < 0.0) {
  290.     new_sw->scale.precision = 0.001;
  291.     XtWarning("Precision has to be a positive number. (forced to 0.001)");
  292.     }
  293.     
  294.     if (new_sw->scale.scale_x_str == DefaultScaleFactor
  295.     || 
  296.     new_sw->scale.scale_y_str == DefaultScaleFactor)
  297.     GetInitialScaleValues(new_sw);
  298.     else {
  299.     if ((new_sw->scale.scale_x = 
  300.          atof(new_sw->scale.scale_x_str)) < 0.0) {
  301.         new_sw->scale.scale_x = 1.0;
  302.         XtWarning("ScaleValue has to be a positive number. (forced to 1.0)");
  303.     }
  304.     if ((new_sw->scale.scale_y = 
  305.          atof(new_sw->scale.scale_y_str)) < 0.0) {
  306.         new_sw->scale.scale_y = 1.0;
  307.         XtWarning("ScaleValue has to be a positive number. (forced to 1.0)");
  308.     }
  309.     }
  310. }
  311.  
  312.  
  313.  
  314. void BuildTable(sw)
  315.     ScaleWidget sw;
  316.     /* 
  317.      * This procedure builds scaling table for image in the scale struct
  318.      * Requires image, scale_x and scale_y to be set properly
  319.      */
  320. {
  321.     Position x, y;
  322.     
  323.     XtFree((char *) sw->scale.table.x);
  324.     XtFree((char *) sw->scale.table.y);
  325.     XtFree((char *) sw->scale.table.width);
  326.     XtFree((char *) sw->scale.table.height);
  327.     sw->scale.table.x = 
  328.     (Position *) XtMalloc(sizeof(Position) * sw->scale.image->width);
  329.     sw->scale.table.y = 
  330.     (Position *) XtMalloc(sizeof(Position) * sw->scale.image->height);
  331.     sw->scale.table.width = 
  332.     (Dimension *) XtMalloc(sizeof(Dimension) * sw->scale.image->width);
  333.     sw->scale.table.height = 
  334.     (Dimension *) XtMalloc(sizeof(Dimension) * sw->scale.image->height);
  335.     
  336.     /* Build the scaling table */    
  337.     for (x = 0; x < sw->scale.image->width; x++) {
  338.     sw->scale.table.x[(int) x] = (Position) myrint(sw->scale.scale_x * x);
  339.     sw->scale.table.width[(int) x] = (Dimension)
  340.         myrint(sw->scale.scale_x *(x + 1)) - myrint(sw->scale.scale_x * x);
  341.     }
  342.     for (y = 0; y < sw->scale.image->height; y++) {
  343.     sw->scale.table.y[(int) y] = (Position) myrint(sw->scale.scale_y * y);
  344.     sw->scale.table.height[(int) y] = (Dimension)
  345.         myrint(sw->scale.scale_y *(y + 1)) - myrint(sw->scale.scale_y * y);
  346.     }
  347. }
  348.  
  349.  
  350.  
  351. void FlushRectangles(sw, drawable, gc)
  352.     ScaleWidget sw;
  353.     Drawable drawable;
  354.     GC gc;
  355. {
  356.     XFillRectangles(XtDisplay(sw), drawable, gc, 
  357.             sw->scale.rectangles, sw->scale.nrectangles);
  358.     
  359.     sw->scale.nrectangles = 0;
  360. }
  361.  
  362.  
  363.  
  364. void FillRectangle(sw, drawable, gc, x, y, width, height)
  365.     ScaleWidget sw;
  366.     Drawable drawable;
  367.     GC gc;
  368.     Position x, y;
  369.     Dimension width, height;
  370. {
  371.     
  372.     if (sw->scale.nrectangles == sw->scale.buffer_size)
  373.     FlushRectangles(sw, drawable, gc);
  374.  
  375.     sw->scale.rectangles[(int) sw->scale.nrectangles].x = x;
  376.     sw->scale.rectangles[(int) sw->scale.nrectangles].y = y;
  377.     sw->scale.rectangles[(int) sw->scale.nrectangles].width = width;
  378.     sw->scale.rectangles[(int) sw->scale.nrectangles].height = height;
  379.  
  380.     ++sw->scale.nrectangles;
  381. }
  382.  
  383.  
  384.  
  385. void ScaleImage(sw, drawable, img_x, img_y, dst_x, dst_y, img_width,img_height)
  386.     ScaleWidget sw;
  387.     Drawable drawable;
  388.     Position img_x, img_y;
  389.     Position dst_x, dst_y;
  390.     Dimension img_width, img_height;
  391.     /* 
  392.      * This procedure scales image into the specified drawable
  393.      * It assumes scaling table was already built
  394.      */
  395. {
  396.     GC gc;
  397.     XGCValues gcv;
  398.     Position x, y;
  399.     Pixel pixel;
  400.     
  401.     /* Clip the img coordinates */
  402.     img_x = min(max(img_x, 0), (Position) sw->scale.image->width - 1);
  403.     img_y = min(max(img_y, 0), (Position) sw->scale.image->height - 1);
  404.     img_width = 
  405.       min(img_width, (Dimension)(sw->scale.image->width - (Dimension)img_x));
  406.     img_height = 
  407.       min(img_height, (Dimension)(sw->scale.image->height - (Dimension)img_y));
  408.  
  409.     if (sw->scale.scale_x == 1.0 && sw->scale.scale_y == 1.0) 
  410.     XPutImage(XtDisplay(sw), drawable, sw->scale.gc, sw->scale.image, 
  411.           img_x, img_y, dst_x, dst_y, 
  412.           img_width, img_height);
  413.     else {
  414.     dst_x = dst_x - sw->scale.table.x[(int) img_x];
  415.     dst_y = dst_y - sw->scale.table.y[(int) img_y];
  416.  
  417.     gc = XCreateGC(XtDisplay(sw), drawable, 0, NULL);
  418.  
  419.     gcv.function = GXcopy;
  420.     XChangeGC(XtDisplay(sw), gc, GCFunction, &gcv);
  421.  
  422.     /* make sure gc knows the right background */
  423.     gcv.background = sw->core.background_pixel;
  424.     XChangeGC(XtDisplay(sw), gc, GCBackground, &gcv);    
  425.  
  426.     /* Set the background of drawable.  If the most frequent color
  427.        is the background color it can speed up scaling process. */
  428.     gcv.foreground = gcv.background;
  429.     XChangeGC(XtDisplay(sw), gc, GCForeground, &gcv);
  430.     XFillRectangle(XtDisplay(sw), drawable, gc, 
  431.                sw->scale.table.x[(int) img_x] + dst_x, 
  432.                sw->scale.table.y[(int) img_y] + dst_y, 
  433.                sw->scale.table.x[(int) img_x + img_width - 1] - 
  434.                sw->scale.table.x[(int) img_x], 
  435.                sw->scale.table.y[(int) img_y + img_height - 1] - 
  436.                sw->scale.table.y[(int) img_y]);
  437.     
  438.     if (sw->scale.image->format == XYBitmap) {
  439.         for (x = img_x; x < img_x + (Position)img_width; x++)
  440.         for (y = img_y; y < img_y + (Position)img_height; y++) {
  441.             pixel = XGetPixel(sw->scale.image, x, y);
  442.             if (pixel) /* Do not draw background */
  443.             FillRectangle(sw, drawable, sw->scale.gc, 
  444.                       sw->scale.table.x[(int) x] + dst_x, 
  445.                       sw->scale.table.y[(int) y] + dst_y, 
  446.                       sw->scale.table.width[(int) x], 
  447.                       sw->scale.table.height[(int) y]);
  448.         }
  449.         FlushRectangles(sw, drawable, sw->scale.gc);
  450.     }
  451.     else {
  452.         for (x = img_x; x < img_x + (Position)img_width; x++)
  453.         for (y = img_y; y < img_y + (Position)img_height; y++) {
  454.             pixel = XGetPixel(sw->scale.image, x, y);
  455.             if (pixel != gcv.background) { /* Do not draw background */
  456.             if (gcv.foreground != pixel) { /* Change fg to pixel */
  457.                 gcv.foreground = pixel;
  458.                 XChangeGC(XtDisplay(sw), gc, GCForeground, &gcv);
  459.             }
  460.             XFillRectangle(XtDisplay(sw), drawable, gc,
  461.                        sw->scale.table.x[(int) x] + dst_x, 
  462.                        sw->scale.table.y[(int) y] + dst_y, 
  463.                        sw->scale.table.width[(int) x], 
  464.                        sw->scale.table.height[(int) y]);
  465.             }
  466.         }
  467.     }
  468.     XFreeGC(XtDisplay(sw), gc);
  469.     }
  470. }
  471.  
  472.  
  473.  
  474. int FindPixel(sw, x, y, img_x, img_y, img_pixel)
  475.     ScaleWidget sw;
  476.     Position x, y; /* (x,y) == (0,0) where image starts in sw window*/
  477.     Position *img_x, *img_y;
  478.     Pixel    *img_pixel;
  479. {
  480.     if (*img_x < 0 || *img_x >= sw->scale.image->width 
  481.     ||
  482.     *img_y < 0 || *img_y >= sw->scale.image->height)
  483.     return (-1);
  484.     
  485.     if (sw->scale.table.x[(int) *img_x] >= x) {
  486.     --*img_x;
  487.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  488.     }
  489.     if (sw->scale.table.x[(int) *img_x] + 
  490.     (Position)sw->scale.table.width[(int) *img_x] < x) {
  491.     ++*img_x;
  492.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  493.     }
  494.     if (sw->scale.table.y[(int) *img_y] >= y) {
  495.     --*img_y;
  496.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  497.     }
  498.     if (sw->scale.table.y[(int) *img_y] + 
  499.     (Position)sw->scale.table.height[(int) *img_y] < y) {
  500.     ++*img_y;
  501.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  502.     }
  503.     
  504.     *img_pixel = XGetPixel(sw->scale.image, *img_x, *img_y);
  505.     
  506.     return (0);
  507. }
  508.  
  509.  
  510.  
  511. int SWGetImagePixel(w, x, y, img_x, img_y, img_pixel)
  512.     Widget w;
  513.     Position x, y;
  514.     Position *img_x, *img_y;
  515.     Pixel    *img_pixel;
  516. {
  517.     ScaleWidget sw = (ScaleWidget) w;
  518.     
  519.     x -= sw->scale.x;
  520.     y -= sw->scale.y;
  521.     
  522.     *img_x = (Position) floor(x / sw->scale.scale_x);
  523.     *img_y = (Position) floor(y / sw->scale.scale_y);
  524.     
  525.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  526. }
  527.  
  528.  
  529.  
  530. /* ARGSUSED */
  531. static void Redisplay(w, event, region)
  532.     Widget w;
  533.     XEvent *event;
  534.     Region region;
  535. {
  536.     ScaleWidget sw = (ScaleWidget) w;
  537.     Position  x, y, img_x, img_y;
  538.     Dimension width, height;
  539.  
  540.     if (event->type == Expose) {
  541.  
  542.     if (event->xexpose.x < sw->scale.x) {
  543.         x = 0;
  544.         width = event->xexpose.width -
  545.         (sw->scale.x - event->xexpose.x);
  546.     }
  547.     else {
  548.         x = event->xexpose.x - sw->scale.x;
  549.         width = event->xexpose.width;
  550.     }
  551.     
  552.     if (event->xexpose.y < sw->scale.y) {
  553.         y = 0;
  554.         height = event->xexpose.height -
  555.         (sw->scale.y - event->xexpose.y);
  556.     }
  557.     else {
  558.         y = event->xexpose.y - sw->scale.y;
  559.         height = event->xexpose.height;
  560.     }
  561.     
  562.     img_x = min(max((Position) floor((float) x 
  563.                      / (float) sw->scale.scale_x), 0),
  564.             (Position) sw->scale.image->width - 1);
  565.  
  566.     img_y = min(max((Position) floor((float) y
  567.                      / (float) sw->scale.scale_y), 0),
  568.             (Position) sw->scale.image->height - 1);
  569.     
  570.     if (sw->core.visible) {  
  571.         ScaleImage(sw, XtWindow(w),
  572.                img_x, img_y,
  573.                sw->scale.x + sw->scale.table.x[(int) img_x],
  574.                sw->scale.y + sw->scale.table.y[(int) img_y],
  575.                (Dimension) ceil((float) width
  576.                     / sw->scale.scale_x) + 1, 
  577.                (Dimension) ceil((float) height
  578.                     / sw->scale.scale_y) + 1);
  579.     }
  580.     }
  581. }
  582.  
  583.  
  584.  
  585. void TryResize(sw)
  586.     ScaleWidget sw;
  587. {
  588.     Dimension width, height;
  589.     XtGeometryResult result;
  590.  
  591.     width = (Dimension) 
  592.     floor(sw->scale.image->width * sw->scale.scale_x)
  593.         + 2 * sw->scale.internal_width;
  594.     height = (Dimension) 
  595.     floor(sw->scale.image->height * sw->scale.scale_y)
  596.         + 2 * sw->scale.internal_height;
  597.     
  598.     while ((result =   
  599. /* SUPPRESS 530 */XtMakeResizeRequest((Widget)sw,width,height,&width,&height))
  600.        == XtGeometryAlmost);  
  601.     
  602.     if (result != XtGeometryNo) {
  603.     sw->core.width = width;
  604.     sw->core.height = height;
  605.     }
  606. }
  607.  
  608.  
  609.  
  610. void Precision(sw)
  611.     ScaleWidget sw;
  612. {
  613.     if (sw->scale.scale_x != 1.0)
  614.     sw->scale.scale_x = floor(sw->scale.scale_x / sw->scale.precision)
  615.                     * sw->scale.precision;
  616.  
  617.     if (sw->scale.scale_y != 1.0)
  618.     sw->scale.scale_y = floor(sw->scale.scale_y / sw->scale.precision)
  619.                 * sw->scale.precision;
  620. }
  621.  
  622.  
  623.  
  624. void Proportional(sw)
  625.     ScaleWidget sw;
  626. {
  627.     float scale_x, scale_y;
  628.  
  629.     scale_x = sw->scale.scale_y / sw->scale.aspect_ratio;
  630.     scale_y = sw->scale.scale_x * sw->scale.aspect_ratio;
  631.     
  632.     if (scale_x <= sw->scale.scale_x && scale_y <= sw->scale.scale_y) {
  633.     if (scale_x > scale_y)
  634.         sw->scale.scale_x = scale_x;
  635.     else
  636.         sw->scale.scale_y = scale_y;
  637.     }
  638.     else if (scale_x <= sw->scale.scale_x)
  639.     sw->scale.scale_x = scale_x;
  640.     else if (scale_y <= sw->scale.scale_y)
  641.     sw->scale.scale_y = scale_y;
  642.     else {
  643.     float x_ratio, y_ratio;
  644.     
  645.     x_ratio = scale_x / sw->scale.scale_x;
  646.     y_ratio = scale_y / sw->scale.scale_y;
  647.     
  648.     if (x_ratio < y_ratio)
  649.         sw->scale.scale_y /= x_ratio;
  650.     else
  651.         sw->scale.scale_x /= y_ratio;
  652.     }
  653.  
  654.     if (fabs(sw->scale.scale_x / sw->scale.scale_y * sw->scale.aspect_ratio 
  655.         - 1.0) > sw->scale.precision)
  656.     XtWarning("can not preserve aspect ratio");
  657. }
  658.  
  659.  
  660.  
  661. void GetScaledSize(sw)
  662.     ScaleWidget sw;
  663. {
  664.     sw->scale.width = (Dimension)
  665.     max(myrint(sw->scale.scale_x * sw->scale.image->width), 1);
  666.     sw->scale.height = (Dimension)
  667.     max(myrint(sw->scale.scale_y * sw->scale.image->height), 1);
  668. }
  669.  
  670.  
  671.  
  672. void GetScaleValues(sw)
  673.     ScaleWidget sw;
  674. {
  675.     /*
  676.      * Make sure to subtract internal width and height.
  677.      */
  678.     
  679.     sw->scale.scale_x = 
  680.     (float) max((int)(sw->core.width - 2 * sw->scale.internal_width), 1)
  681.         / (float) sw->scale.image->width;
  682.  
  683.     sw->scale.scale_y =
  684.     (float) max((int)(sw->core.height - 2 * sw->scale.internal_height), 1)
  685.         / (float) sw->scale.image->height;
  686. }
  687.  
  688.  
  689.  
  690. void Unscale(sw)
  691.     ScaleWidget sw;
  692. {
  693.     sw->scale.scale_x = sw->scale.scale_y = 1.0;
  694.  
  695.     GetScaledSize(sw);        
  696.     
  697.     BuildTable(sw);
  698. }
  699.  
  700.  
  701.  
  702. void Autoscale(sw)
  703.     ScaleWidget sw;
  704. {
  705.     GetScaleValues(sw);
  706.  
  707.     if (sw->scale.proportional) Proportional(sw);
  708.  
  709.     Precision(sw);
  710.  
  711.     GetScaledSize(sw);
  712.     
  713.     BuildTable(sw);
  714. }
  715.  
  716.  
  717.  
  718. void PositionImage(sw)
  719.     ScaleWidget sw;
  720. {
  721.     /*
  722.      * Set as if for ForgegGravity (that is center the image)
  723.      */
  724.     sw->scale.x = (Position) 
  725.     (sw->core.width - sw->scale.width) / 2;
  726.     sw->scale.y = (Position)
  727.     (sw->core.height - sw->scale.height) / 2;
  728.     
  729. /*****
  730.     if (sw->scale.gravity & WestGravity) { 
  731.     }
  732.     if (sw->scale.gravity & EastGravity) { 
  733.     }
  734.     if (sw->scale.gravity & NorthGravity) {
  735.     }
  736.     if (sw->scale.gravity & SouthGravity) {
  737.     }
  738. *****/
  739. }
  740.  
  741.  
  742.  
  743. static void Resize(w)
  744.     Widget w;
  745. {
  746.     ScaleWidget sw = (ScaleWidget) w;
  747.     
  748.     if (sw->scale.autoscale) Autoscale(sw);
  749.     
  750.     PositionImage(sw);
  751. }
  752.  
  753.  
  754.  
  755. static void Realize(wid, vmask, attr)
  756.         Widget wid;
  757.         Mask *vmask;
  758.         XSetWindowAttributes *attr;
  759. {
  760.   ScaleWidget sw = (ScaleWidget) wid;
  761.   XtCreateWindow(wid, (unsigned int) InputOutput,
  762.          (Visual *) sw->scale.visual, *vmask, attr);
  763. }
  764.  
  765.  
  766.  
  767. static void Destroy(w)
  768.     Widget w;
  769. {
  770.     ScaleWidget sw = (ScaleWidget) w; 
  771.  
  772.     XtFree((char *) sw->scale.table.x);
  773.     XtFree((char *) sw->scale.table.y);
  774.     XtFree((char *) sw->scale.table.width);
  775.     XtFree((char *) sw->scale.table.height);
  776.     
  777.     XtFree((char *) sw->scale.rectangles);
  778.  
  779.     XtReleaseGC(w, sw->scale.gc);
  780.  
  781.     XDestroyImage(sw->scale.image);
  782. }
  783.  
  784.  
  785.  
  786. /* ARGSUSED */
  787. static Boolean SetValues(current, request, new, args, num_args)
  788.     Widget current, request, new;
  789.     ArgList args;
  790.     Cardinal *num_args;
  791. {
  792.     ScaleWidget cur_sw = (ScaleWidget) current;
  793.     /* ScaleWidget req_sw = (ScaleWidget) request; */
  794.     ScaleWidget new_sw = (ScaleWidget) new;
  795.     Boolean redisplay = False;
  796.     int i;
  797.     
  798.     for (i = 0; i < *num_args; i++) {
  799.     if (streq(XtNbackground, args[i].name)) {
  800.         XSetBackground(XtDisplay(new), new_sw->scale.gc, 
  801.                new_sw->core.background_pixel);
  802.     }
  803.     if (streq(XtNforeground, args[i].name)) {
  804.         XSetForeground(XtDisplay(new), new_sw->scale.gc, 
  805.                new_sw->scale.foreground_pixel);
  806.     }
  807.     if (streq(XtNimage, args[i].name)) {
  808.         XDestroyImage(cur_sw->scale.image);
  809.         if (new_sw->scale.image == NULL)
  810.         new_sw->scale.image = XCreateImage(XtDisplay(new),
  811.                         DefaultVisual(XtDisplay(new), 
  812.                         DefaultScreen(XtDisplay(new))),
  813.                            1, XYBitmap, 0, 
  814.                            XtCalloc(1, sizeof(char)),
  815.                            1, 1, 8, 0);
  816.         else
  817.         new_sw->scale.image = 
  818.             XSubImage(new_sw->scale.image, 
  819.                   0, 0, 
  820.                   new_sw->scale.image->width, 
  821.                   new_sw->scale.image->height);
  822.  
  823.         if (new_sw->scale.resize)
  824.         TryResize(new_sw);
  825.         if (new_sw->scale.autoscale)
  826.         Autoscale(new_sw);
  827.         else {
  828.         GetScaledSize(new_sw);
  829.         BuildTable(new_sw);
  830.         }
  831.         PositionImage(new_sw);
  832.         redisplay = True;
  833.     }
  834.  
  835.     if (streq(XtNuserData, args[i].name)) 
  836.       new_sw->scale.userData = (XtPointer)args[i].value;
  837.  
  838.     if (streq(XtNbufferSize, args[i].name)) {
  839.         if (new_sw->scale.buffer_size != cur_sw->scale.buffer_size) {
  840.         GetRectangleBuffer(new_sw, new_sw->scale.buffer_size);
  841.         }
  842.     }
  843.  
  844.     if (streq(XtNaspectRatio, args[i].name)) {
  845.         if ((new_sw->scale.aspect_ratio = 
  846.          atof(new_sw->scale.aspect_ratio_str)) < 0.0) {
  847.         new_sw->scale.aspect_ratio = cur_sw->scale.aspect_ratio;
  848.         XtWarning("AspectRatio has to be a positive number.");
  849.         }
  850.         else if (new_sw->scale.aspect_ratio != cur_sw->scale.aspect_ratio){
  851.         if (new_sw->scale.proportional) {
  852.             Proportional(new_sw);
  853.             Precision(new_sw);
  854.             GetScaledSize(new_sw);
  855.             BuildTable(new_sw);
  856.             PositionImage(new_sw);
  857.             redisplay = True;
  858.         }
  859.         }
  860.     }
  861.     
  862.     if (streq(XtNproportional, args[i].name)) {
  863.         if (new_sw->scale.proportional != cur_sw->scale.proportional) {
  864.         if (new_sw->scale.proportional) Proportional(new_sw);
  865.         Precision(new_sw);
  866.         GetScaledSize(new_sw);
  867.         BuildTable(new_sw);
  868.         PositionImage(new_sw);
  869.         redisplay = True;
  870.         }
  871.     }
  872.     
  873.     if (streq(XtNscaleX, args[i].name)
  874.         || 
  875.         streq(XtNscaleY, args[i].name)) {
  876.         if (new_sw->scale.scale_x_str == DefaultScaleFactor
  877.         || 
  878.         new_sw->scale.scale_y_str == DefaultScaleFactor)
  879.         GetInitialScaleValues(new_sw);
  880.         else {
  881.         if ((new_sw->scale.scale_x = 
  882.              atof(new_sw->scale.scale_x_str)) < 0.0) {
  883.             new_sw->scale.scale_x = cur_sw->scale.scale_x;
  884.             XtWarning("ScaleValue has to be a positive number.");
  885.         }
  886.         if ((new_sw->scale.scale_y = 
  887.              atof(new_sw->scale.scale_y_str)) < 0.0) {
  888.             new_sw->scale.scale_y = cur_sw->scale.scale_y;
  889.             XtWarning("ScaleValue has to be a positive number.");
  890.         }
  891.         }
  892.         if (new_sw->scale.scale_x != cur_sw->scale.scale_x
  893.         ||
  894.         new_sw->scale.scale_y != cur_sw->scale.scale_y) {
  895.         
  896.         /*?*?*?*?*?*?*?*?*?*?*?*?*?*?**?*?*?*?*?*?*?*?*?***?*/
  897.         fprintf(stderr, "================>>%f %f\n",
  898.             new_sw->scale.scale_x, new_sw->scale.scale_y);
  899.         
  900.         if (new_sw->scale.proportional) Proportional(new_sw);
  901.         Precision(new_sw);
  902.         if (new_sw->scale.resize)
  903.             TryResize(new_sw);
  904.         GetScaledSize(new_sw);        
  905.         BuildTable(new_sw);
  906.         PositionImage(new_sw);
  907.         redisplay = True;
  908.         }
  909.     }
  910.     
  911.     if (streq(XtNprecision, args[i].name)) {
  912.         if ((new_sw->scale.precision = 
  913.          atof(new_sw->scale.precision_str)) < 0.0) {
  914.         new_sw->scale.precision = cur_sw->scale.precision;
  915.         XtWarning("Precision has to be a positive number.");
  916.         }
  917.         if (new_sw->scale.precision != cur_sw->scale.precision) {
  918.         if (new_sw->scale.proportional) Proportional(new_sw);
  919.         Precision(new_sw);
  920.         GetScaledSize(new_sw);        
  921.         BuildTable(new_sw);
  922.         PositionImage(new_sw);
  923.         redisplay = True;
  924.         }
  925.     }
  926.     }            
  927.     return(redisplay);
  928. }
  929.  
  930.  
  931.  
  932. void SWUnscale(w)
  933.     Widget w;
  934. {
  935.     ScaleWidget sw = (ScaleWidget) w;
  936.  
  937.     Unscale(sw);
  938.     PositionImage(sw);
  939.     XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, True);
  940. }
  941.  
  942.  
  943.  
  944. void SWAutoscale(w)
  945.     Widget w;
  946. {
  947.     ScaleWidget sw = (ScaleWidget) w;
  948.  
  949.     Autoscale(sw);
  950.     PositionImage(sw);
  951.     XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, True);
  952. }
  953.  
  954.  
  955.  
  956. void SWInitialSize(w)
  957.     Widget w;
  958. {
  959.     ScaleWidget sw = (ScaleWidget) w;
  960.     
  961.     GetInitialScaleValues(sw);
  962.  
  963.     if (sw->scale.proportional) Proportional(sw);
  964.     Precision(sw);
  965.     if (sw->scale.resize)
  966.     TryResize(sw);
  967.     GetScaledSize(sw);        
  968.     BuildTable(sw);
  969.     PositionImage(sw);
  970.     XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, True);
  971. }
  972.  
  973.  
  974.  
  975. void SWSetImage(w, image)
  976.     Widget w;
  977.     XImage *image;
  978. {
  979.     int n;
  980.     Arg wargs[2];
  981.     
  982.     n = 0;
  983.     XtSetArg(wargs[n], XtNimage, (XtArgVal) image); n++;
  984.     XtSetValues(w, wargs, n);
  985. }
  986.  
  987.  
  988.  
  989. extern void SWRequestSelection();
  990.  
  991. void RequestSelection(w, event)
  992.     Widget w;
  993.     XEvent *event;
  994. {
  995.     SWRequestSelection(w, event->xbutton.time);
  996. }
  997.  
  998.  
  999.  
  1000. extern void SWGrabSelection();
  1001.  
  1002. void GrabSelection(w, event)
  1003.     Widget w;
  1004.     XEvent *event;
  1005. {
  1006.     SWGrabSelection(w, event->xbutton.time);
  1007. }
  1008.  
  1009.  
  1010.  
  1011. Pixmap SWGetPixmap(w)
  1012.     Widget w;
  1013. {
  1014.     ScaleWidget sw = (ScaleWidget) w;
  1015.     Pixmap pixmap;
  1016.  
  1017.     pixmap = XCreatePixmap(XtDisplay(w), XtWindow(w), 
  1018.                sw->scale.width, 
  1019.                sw->scale.height, 
  1020.                sw->scale.image->depth);
  1021.     ScaleImage(sw, pixmap, 
  1022.            0, 0, 0, 0, 
  1023.            (Dimension) sw->scale.image->width, 
  1024.            (Dimension) sw->scale.image->height);
  1025.     
  1026.     return(pixmap);
  1027. }
  1028.